home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / RTANKSRC.ZIP / PARSE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-12-06  |  23.5 KB  |  967 lines
  1. /**--------------------------------------------------------------
  2.  **  Ralcool Software - Simulation - 1988
  3.  **--------------------------------------------------------------
  4.  ** MODULE     : PARSE.C
  5.  ** PURPOSE    : <t> parse out file into interpreter structure
  6.  ** PROGRAMMER : Sandy
  7.  ** START DATE : 11/28/1988 06:57:38
  8.  ** DESCRIPTION:
  9.  **            :
  10.  **            :
  11.  **==============================================================
  12.  **/
  13.  
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <dtypes.h>
  18. #include <conio.h>
  19.  
  20. #include "shop.h"
  21. #include "code.h"
  22.  
  23. #include "parse.h"
  24.  
  25. char vars[100][20];
  26.  
  27. #define MAXCLINES 1000
  28.  
  29. int  nlabels=0;
  30. int  nlinks =0;
  31. int  nvars  =0;
  32. int  nlines =0;
  33. int  resolve=0;
  34. int  pline  =0;
  35. int  cerror =0;
  36.  
  37. LINK {
  38.    char   label[20];
  39. };
  40.  
  41. LINE {
  42.    WORD    w_command;
  43.    int     phyline;
  44.    ARG     arg1, arg2, arg3, arg4;
  45. };
  46.  
  47. LABEL {
  48.    int     n_lineref;
  49.    char    c_label[20];
  50. };
  51.  
  52. LINK    link[100];
  53. p_LINE  line[MAXCLINES];
  54. LINE    cline;
  55. LABEL   labels[100];
  56.  
  57. BOOL  b_append = FALSE;
  58. BOOL  b_good_pass = TRUE;
  59.  
  60. WINDOW w3;
  61.  
  62. PSTR errormess[] = {
  63.             "COMPILER ERROR",
  64.             "Symbol exists",
  65.             "Symbol table overflow",
  66.             "Symbol undefined",
  67.             "Syntax error or no argument",
  68.             "Symbol required as first argument",
  69.             "Label already used",
  70.             "Line reference not allowed as arg",
  71.             "Line reference required",
  72.             ""
  73. };
  74.  
  75. #define _SYMUSED   1
  76. #define _VAROVER   2
  77. #define _UNDEF     3
  78. #define _SYNTAX    4
  79. #define _SYMREQ1   5
  80. #define _LABELUSED 6
  81. #define _NOLINE    7
  82. #define _LINEMUST  8
  83.  
  84. /*<f>----------------------------------------
  85.  * FUNCTION: <s> void v_parse_main(PSTR s);
  86.  * PURPOSE : Parser program start
  87.  *         :
  88.  * CREATION: 11/28/1988 06:59:16
  89.  */
  90. void v_parse_main(PSTR s)
  91. {
  92.  
  93.    v_open_window(&w3,10,4,70,20);
  94.  
  95.    textcolor(LIGHTGRAY); textbackground(BLACK);
  96.    gotoxy(30,4); cprintf(" %s ",s);
  97.  
  98.    window(11,5,69,20);
  99.    textcolor(YELLOW); textbackground(BLUE);
  100.  
  101.    nlabels=0;
  102.    nlinks =0;
  103.    nvars  =0;
  104.    nlines =0;
  105.    resolve=0;
  106.    pline  =0;
  107.    b_append    = FALSE;
  108.    b_good_pass = TRUE;
  109.  
  110.    v_begin_parse(s);
  111.  
  112.    if (b_good_pass)
  113.       v_write_code(s);
  114.  
  115.    v_free_compiler_ram();
  116.  
  117.    gotoxy(1,15);
  118.    cprintf("%s : PRESS ENTER",(b_good_pass) ? "SUCCESS" : "FAILURE");
  119.    getchar();
  120.  
  121.    v_close_window(&w3);
  122.  
  123.    window(1,1,80,25);
  124.  
  125. } /* void void v_parse_main(PSTR s); */
  126.  
  127. /*<f>----------------------------------------
  128.  * FUNCTION: <s> void v_begin_parse(PSTR fn)
  129.  * PURPOSE : Open file fn and begin parsing
  130.  *         :
  131.  * CREATION: 11/28/1988 07:01:42
  132.  */
  133. void v_begin_parse(PSTR fn)
  134. {
  135. FILE *fp;
  136. char c_copy[100], c_buf[100], *p;
  137. int a;
  138.  
  139.    if ((fp=fopen(fn,"rt"))==NULL) {
  140.       cprintf("\n\rCannot open \"%s\" for input\n\r",fn);
  141.       b_good_pass=FALSE;
  142.    } else {
  143.  
  144.       while (fgets(c_buf,100,fp)) {
  145.          pline++;
  146.  
  147.          strcpy(c_copy,c_buf);
  148.  
  149.          p=c_buf;
  150.          while ((*p)!=';' && (*p)) p++;
  151.          if ((*p)==';')
  152.             (*p)=NULL;
  153.  
  154.          cline.phyline       =pline;
  155.          cline.w_command     =UNUSED;
  156.          cline.arg1.n_ArgType=UNUSED;
  157.          cline.arg1.n_value  =UNUSED;
  158.          cline.arg2.n_ArgType=UNUSED;
  159.          cline.arg2.n_value  =UNUSED;
  160.          cline.arg3.n_ArgType=UNUSED;
  161.          cline.arg3.n_value  =UNUSED;
  162.  
  163.          switch (w_parse(c_buf)) {
  164.             case 0 : if (b_append) {
  165.                         if (nlines>MAXCLINES) {
  166.                            printf("Too many lines for compiler\n");
  167.                            exit(1);
  168.                         }
  169.                         if ((line[nlines] = (p_LINE) malloc(sizeof(LINE)))==NULL) {
  170.                            printf("Cannot malloc ram for source code\n");
  171.                            exit(1);
  172.                         }
  173.                         memcpy(line[nlines++],&cline,sizeof(LINE));
  174.                      }
  175.                      break;
  176.             default: cprintf("%s (%d): %s\r",errormess[cerror],pline,c_copy);
  177.                      b_good_pass=FALSE;
  178.                      break;
  179.          }
  180.       }
  181.       fclose(fp);
  182.  
  183.       v_conclude_resolves();
  184.  
  185.    }
  186. } /* void v_begin_parse(PSTR fn) */
  187.  
  188. /*<f>----------------------------------------
  189.  * FUNCTION: <s> WORD w_parse(PSTR s)
  190.  * PURPOSE : Break down string s into it's component parts
  191.  *         :
  192.  * CREATION: 11/28/1988 07:32:08
  193.  */
  194. WORD w_parse(PSTR s)
  195. {
  196. PSTR p;
  197. char t[20][20];
  198. WORD wc, werror;
  199. int a;
  200.  
  201.    strupr(s);
  202.  
  203.    memset(t,0,sizeof(t));
  204.  
  205.    p = strtok(s," ,\n\t");
  206.    wc=0;
  207.  
  208.    while (p!=NULL) {
  209.       strcpy(t[wc++],p);
  210.       p = strtok(NULL," ,\n\t");
  211.    }
  212.  
  213.    b_append=TRUE;
  214.  
  215.    if (wc>0)
  216.       werror=w_fill_structure(t);
  217.    else {
  218.       werror=0; b_append=FALSE;
  219.    }
  220.  
  221.    return werror;
  222. } /* WORD w_parse(PSTR s) */
  223.  
  224. /*<f>----------------------------------------
  225.  * FUNCTION: <s> WORD w_fill_structure(char t[20][20])
  226.  * PURPOSE : Fills a structure with the tokens passed
  227.  *         :
  228.  * CREATION: 11/28/1988 07:53:00
  229.  */
  230. WORD w_fill_structure(char t[20][20])
  231. {
  232. WORD w_return=0;
  233.  
  234.    if (t[0][0]==':') {                                      /* New line ref */
  235.       b_append=FALSE;
  236.       if (!b_add_label(t[0]))
  237.          w_return=1;
  238.    } else if (strcmp(t[0],"MAKE")==0) {                     /* make */
  239.       b_append=FALSE;
  240.       if (!b_add_symbol(t[1]))
  241.          w_return=1;
  242.    } else if (strcmp(t[0],"RADAR")==0) {                    /* radar */
  243.       if (!b_make_radar(t[1]))
  244.          w_return=1;
  245.    } else if (strcmp(t[0],"SCAN")==0) {                     /* scan */
  246.       if (!b_make_scan(t[1],t[2]))
  247.          w_return=1;
  248.    } else if (strcmp(t[0],"WHEREX")==0) {                   /* wherex */
  249.       if (!b_store_x(t[1]))
  250.          w_return=1;
  251.    } else if (strcmp(t[0],"WHEREY")==0) {                   /* wherey */
  252.       if (!b_store_y(t[1]))
  253.          w_return=1;
  254.    } else if (strcmp(t[0],"CGDIR")==0) {                    /* cgdir */
  255.       if (!b_curr_gun(t[1]))
  256.          w_return=1;
  257.    } else if (strcmp(t[0],"CTDIR")==0) {                    /* ctdir */
  258.       if (!b_curr_tank(t[1]))
  259.          w_return=1;
  260.    } else if (strcmp(t[0],"SELECT")==0) {                   /* select */
  261.       if (!b_select_weapon(t[1]))
  262.          w_return=1;
  263.    } else if (strcmp(t[0],"JEQ")==0) {                      /* jeq */
  264.       if (!b_cond_jump(_JUMPEQ,t[1],t[2],t[3]))
  265.          w_return=1;
  266.    } else if (strcmp(t[0],"JLT")==0) {                      /* jlt */
  267.       if (!b_cond_jump(_JUMPLESS,t[1],t[2],t[3]))
  268.          w_return=1;
  269.    } else if (strcmp(t[0],"JNEQ")==0) {                     /* jneq */
  270.       if (!b_cond_jump(_JUMPNEQ,t[1],t[2],t[3]))
  271.          w_return=1;
  272.    } else if (strcmp(t[0],"JGT")==0) {                      /* jgt */
  273.       if (!b_cond_jump(_JUMPGRT,t[1],t[2],t[3]))
  274.          w_return=1;
  275.    } else if (strcmp(t[0],"LEFT")==0) {                     /* left */
  276.       if (!b_turn_left())
  277.          w_return=1;
  278.    } else if (strcmp(t[0],"RIGHT")==0) {                    /* right */
  279.       if (!b_turn_right())
  280.          w_return=1;
  281.    } else if (strcmp(t[0],"GLEFT")==0) {                    /* gleft */
  282.       if (!b_turn_gleft())
  283.          w_return=1;
  284.    } else if (strcmp(t[0],"GRIGHT")==0) {                   /* gright */
  285.       if (!b_turn_gright())
  286.          w_return=1;
  287.    } else if (strcmp(t[0],"SET")==0) {                      /* set */
  288.       if (!b_do_set(t[1],t[2]))
  289.          w_return=1;
  290.    } else if (strcmp(t[0],"ADD")==0) {                      /* add */
  291.       if (!b_do_add(t[1],t[2]))
  292.          w_return=1;
  293.    } else if (strcmp(t[0],"RAND")==0) {                     /* rand */
  294.       if (!b_do_rand(t[1],t[2]))
  295.          w_return=1;
  296.    } else if (strcmp(t[0],"MOVE")==0) {                     /* move */
  297.       if (!b_do_move())
  298.          w_return=1;
  299.    } else if (strcmp(t[0],"GOTO")==0) {                     /* goto */
  300.       if (!b_normal_jump(_JUMP,t[1]))
  301.          w_return=1;
  302.    } else if (strcmp(t[0],"FIRE")==0) {                     /* fire */
  303.       if (!b_do_fire())
  304.          w_return=1;
  305.    } else if (strcmp(t[0],"CALL")==0) {                     /* call */
  306.       if (!b_normal_jump(_CALL,t[1]))
  307.          w_return=1;
  308.    } else if (strcmp(t[0],"LOADED")==0) {                   /* loaded */
  309.       if (!b_loaded(t[1]))
  310.          w_return=1;
  311.    } else if (strcmp(t[0],"RETURN")==0)                     /* return */
  312.       b_do_return();
  313.    else {
  314.       cerror=_SYNTAX;
  315.       w_return=1;
  316.    }
  317.  
  318.    return w_return;
  319. } /* WORD w_fill_structure(char t[20][20]) */
  320.  
  321. /*<f>----------------------------------------
  322.  * FUNCTION: <s> BOOL b_add_symbol(PSTR p)
  323.  * PURPOSE : Add symbol p to symbol table
  324.  *         : return FALSE if couldn't be added
  325.  * CREATION: 11/28/1988 08:25:06
  326.  */
  327. BOOL b_add_symbol(PSTR p)
  328. {
  329.    if (nvars>=100) {
  330.       cerror=_VAROVER;
  331.       return FALSE;
  332.    }
  333.  
  334.    if (n_find_symbol(p) != UNUSED) {
  335.       cerror=_SYMUSED;
  336.       return FALSE;
  337.    }
  338.  
  339.    strcpy(vars[nvars++],p);
  340.  
  341.    return TRUE;
  342. } /* BOOL b_add_symbol(PSTR p) */
  343.  
  344. /*<f>----------------------------------------
  345.  * FUNCTION: <s> int n_find_symbol(PSTR s)
  346.  * PURPOSE : Searchs symbol table to find s
  347.  *         :
  348.  * CREATION: 11/28/1988 08:48:55
  349.  */
  350. int n_find_symbol(PSTR s)
  351. {
  352. int a;
  353.  
  354.    for (a=0; a<nvars; a++)
  355.       if (strcmp(vars[a],s)==0)
  356.          return a;
  357.  
  358.    return UNUSED;
  359. } /* int n_find_symbol(PSTR s) */
  360.  
  361. /*<f>----------------------------------------
  362.  * FUNCTION: <s> BOOL b_store_x(PSTR s)
  363.  * PURPOSE : Store X location in symbol S
  364.  *         :
  365.  * CREATION: 11/28/1988 09:17:51
  366.  */
  367. BOOL b_store_x(PSTR s)
  368. {
  369. int n_sym;
  370.  
  371.    n_sym=n_find_symbol(s);
  372.    if (n_sym==UNUSED) {
  373.       cerror=_UNDEF;
  374.       return FALSE;
  375.    }
  376.  
  377.    cline.w_command=_WHEREX;
  378.    if (!b_parse_arg(&cline.arg1,s)) {
  379.       cerror=_SYNTAX;
  380.       return FALSE;
  381.    }
  382.  
  383.    if (cline.arg1.n_ArgType!=SYMBOL) {
  384.       cerror=_SYMREQ1;
  385.       return FALSE;
  386.    } else
  387.       return TRUE;
  388. } /* BOOL b_store_x(PSTR s) */
  389.  
  390. /*<f>----------------------------------------
  391.  * FUNCTION: <s> BOOL b_curr_gun(PSTR s)
  392.  * PURPOSE : Store current gun position
  393.  *         :
  394.  * CREATION: 12/05/1988 17:43:11
  395.  */
  396. BOOL b_curr_gun(PSTR s)
  397. {
  398. int n_sym;
  399.  
  400.    n_sym=n_find_symbol(s);
  401.    if (n_sym==UNUSED) {
  402.       cerror=_UNDEF;
  403.       return FALSE;
  404.    }
  405.  
  406.    cline.w_command=_CGDIR;
  407.    if (!b_parse_arg(&cline.arg1,s)) {
  408.       cerror=_SYNTAX;
  409.       return FALSE;
  410.    }
  411.  
  412.    if (cline.arg1.n_ArgType!=SYMBOL) {
  413.       cerror=_SYMREQ1;
  414.       return FALSE;
  415.    } else
  416.       return TRUE;
  417. } /* BOOL b_curr_gun(PSTR s) */
  418.  
  419. /*<f>----------------------------------------
  420.  * FUNCTION: <s> BOOL b_curr_tank(PSTR s)
  421.  * PURPOSE : Store current tank direction
  422.  *         :
  423.  * CREATION: 12/05/1988 17:45:36
  424.  */
  425. BOOL b_curr_tank(PSTR s)
  426. {
  427. int n_sym;
  428.  
  429.    n_sym=n_find_symbol(s);
  430.    if (n_sym==UNUSED) {
  431.       cerror=_UNDEF;
  432.       return FALSE;
  433.    }
  434.  
  435.    cline.w_command=_CTDIR;
  436.    if (!b_parse_arg(&cline.arg1,s)) {
  437.       cerror=_SYNTAX;
  438.       return FALSE;
  439.    }
  440.  
  441.    if (cline.arg1.n_ArgType!=SYMBOL) {
  442.       cerror=_SYMREQ1;
  443.       return FALSE;
  444.    } else
  445.       return TRUE;
  446. } /* BOOL b_curr_tank(PSTR s) */
  447.  
  448. /*<f>----------------------------------------
  449.  * FUNCTION: <s> BOOL b_select_weapon(PSTR s)
  450.  * PURPOSE : Select current weapon
  451.  *         :
  452.  * CREATION: 12/05/1988 17:46:57
  453.  */
  454. BOOL b_select_weapon(PSTR s)
  455. {
  456.    cline.w_command=_SELECT;
  457.    if (!b_parse_arg(&cline.arg1,s)) {
  458.       cerror=_SYNTAX;
  459.       return FALSE;
  460.    }
  461.  
  462.    return TRUE;
  463. } /* BOOL b_select_weapon(PSTR s) */
  464.  
  465. /*<f>----------------------------------------
  466.  * FUNCTION: <s> BOOL b_store_y(PSTR s)
  467.  * PURPOSE : Store current Y location in symbol S
  468.  *         :
  469.  * CREATION: 11/28/1988 09:40:04
  470.  */
  471. BOOL b_store_y(PSTR s)
  472. {
  473. int n_sym;
  474.  
  475.    n_sym=n_find_symbol(s);
  476.    if (n_sym==UNUSED) {
  477.       cerror=_UNDEF;
  478.       return FALSE;
  479.    }
  480.  
  481.    cline.w_command=_WHEREY;
  482.    if (!b_parse_arg(&cline.arg1,s)) {
  483.       cerror=_SYNTAX;
  484.       return FALSE;
  485.    }
  486.  
  487.    if (cline.arg1.n_ArgType!=SYMBOL) {
  488.       cerror=_SYMREQ1;
  489.       return FALSE;
  490.    } else
  491.       return TRUE;
  492. } /* BOOL b_store_y(PSTR s) */
  493.  
  494. /*<f>----------------------------------------
  495.  * FUNCTION: <s> BOOL b_turn_left(void)
  496.  * PURPOSE : Turn tank counter-clockwise
  497.  *         :
  498.  * CREATION: 12/05/1988 17:25:54
  499.  */
  500. BOOL b_turn_left(void)
  501. {
  502.    cline.w_command=_LEFT;
  503.    return TRUE;
  504. } /* BOOL b_turn_left(void) */
  505.  
  506. /*<f>----------------------------------------
  507.  * FUNCTION: <s> BOOL b_turn_right(void)
  508.  * PURPOSE : Turn tank clockwise
  509.  *         :
  510.  * CREATION: 12/05/1988 17:26:45
  511.  */
  512. BOOL b_turn_right(void)
  513. {
  514.    cline.w_command=_RIGHT;
  515.    return TRUE;
  516. } /* BOOL b_turn_right(void) */
  517.  
  518. /*<f>----------------------------------------
  519.  * FUNCTION: <s> BOOL b_turn_gleft(void)
  520.  * PURPOSE : aim gun counterclockwise
  521.  *         :
  522.  * CREATION: 12/05/1988 17:29:01
  523.  */
  524. BOOL b_turn_gleft(void)
  525. {
  526.    cline.w_command=_GLEFT;
  527.    return TRUE;
  528. } /* BOOL b_turn_gleft(void) */
  529.  
  530. /*<f>----------------------------------------
  531.  * FUNCTION: <s> BOOL b_turn_gright(void)
  532.  * PURPOSE : aim gun clockwise
  533.  *         :
  534.  * CREATION: 12/05/1988 17:38:18
  535.  */
  536. BOOL b_turn_gright(void)
  537. {
  538.    cline.w_command=_GRIGHT;
  539.    return TRUE;
  540. } /* BOOL b_turn_gright(void) */
  541.  
  542. /*<f>----------------------------------------
  543.  * FUNCTION: <s> BOOL b_parse_arg(p_ARG parg, PSTR s)
  544.  * PURPOSE : Parse out an argument as a constant, variable or
  545.  *         : line number
  546.  * CREATION: 11/28/1988 12:02:30
  547.  */
  548. BOOL b_parse_arg(p_ARG parg, PSTR s)
  549. {
  550. BOOL ret;
  551.  
  552.    if (!s) return FALSE;
  553.  
  554.    if (s[0]==':') {
  555.       parg->n_ArgType=LINEREF;
  556.       if ((parg->n_value=n_find_label(s))==UNUSED)
  557.          v_add_resolve(s);
  558.       ret = TRUE;
  559.    } else if (s[0]=='-' || (s[0]>='0' && s[0]<='9')) {
  560.       parg->n_ArgType=CONSTANT;
  561.       parg->n_value=atoi(s);
  562.       ret=TRUE;
  563.    } else {
  564.       parg->n_ArgType=SYMBOL;
  565.       parg->n_value=n_find_symbol(s);
  566.       ret = (parg->n_value==UNUSED) ? FALSE : TRUE;
  567.    }
  568.  
  569.    return ret;
  570. } /* BOOL b_parse_arg(p_ARG parg, PSTR s) */
  571.  
  572. /*<f>----------------------------------------
  573.  * FUNCTION: <s> BOOL b_add_label(PSTR p)
  574.  * PURPOSE : Add line label P to list
  575.  *         :
  576.  * CREATION: 11/28/1988 12:32:15
  577.  */
  578. BOOL b_add_label(PSTR p)
  579. {
  580.    if (n_find_label(p)!=UNUSED) {
  581.       cerror=_LABELUSED;
  582.       return FALSE;
  583.    }
  584.  
  585.    labels[nlabels].n_lineref=nlines;
  586.    strcpy(labels[nlabels++].c_label,p);
  587.  
  588.    return TRUE;
  589. } /* BOOL b_add_label(PSTR p) */
  590.  
  591. /*<f>----------------------------------------
  592.  * FUNCTION: <s> int n_find_label(PSTR p)
  593.  * PURPOSE : Find line reference P in list
  594.  *         : returns UNUSED if not found
  595.  * CREATION: 11/28/1988 12:36:55
  596.  */
  597. int n_find_label(PSTR p)
  598. {
  599. int a;
  600.  
  601.    for (a=0; a<nlabels; a++)
  602.       if (strcmp(labels[a].c_label,p)==0)
  603.          return labels[a].n_lineref;
  604.  
  605.    return UNUSED;
  606. } /* int n_find_label(PSTR p) */
  607.  
  608. /*<f>----------------------------------------
  609.  * FUNCTION: <s> BOOL b_cond_jump(int ntype,PSTR s1, PSTR s2, PSTR s3)
  610.  * PURPOSE : Do a ntype conditional jump with arguments s1,s2,s3
  611.  *         :
  612.  * CREATION: 11/28/1988 12:47:55
  613.  */
  614. BOOL b_cond_jump(int ntype,PSTR s1, PSTR s2, PSTR s3)
  615. {
  616.    if (!b_parse_arg(&cline.arg1,s1) ||
  617.        !b_parse_arg(&cline.arg2,s2) ||
  618.        !b_parse_arg(&cline.arg3,s3)) {
  619.           cerror=_SYNTAX;
  620.           return FALSE;
  621.    }
  622.  
  623.    if (cline.arg1.n_ArgType==LINEREF ||
  624.        cline.arg2.n_ArgType==LINEREF) {
  625.           cerror=_NOLINE;
  626.           return FALSE;
  627.    }
  628.    if (cline.arg3.n_ArgType!=LINEREF) {
  629.       cerror=_LINEMUST;
  630.       return FALSE;
  631.    }
  632.    cline.w_command=ntype;
  633.  
  634.    return TRUE;
  635. } /* BOOL b_cond_jump(int ntype,PSTR s1, PSTR s2, PSTR s3) */
  636.  
  637. /*<f>----------------------------------------
  638.  * FUNCTION: <s> BOOL b_normal_jump(int ntype, PSTR s)
  639.  * PURPOSE : Do a normal jump command
  640.  *         :
  641.  * CREATION: 11/28/1988 12:59:10
  642.  */
  643. BOOL b_normal_jump(int ntype, PSTR s)
  644. {
  645.   if (!b_parse_arg(&cline.arg1,s)) {
  646.       cerror=_SYNTAX;
  647.       return FALSE;
  648.   }
  649.  
  650.    if (cline.arg1.n_ArgType!=LINEREF) {
  651.       cerror=_LINEMUST;
  652.       return FALSE;
  653.    }
  654.  
  655.    cline.w_command=ntype;
  656.  
  657.    return TRUE;
  658. } /* BOOL b_normal_jump(int ntype, PSTR s) */
  659.  
  660. /*<f>----------------------------------------
  661.  * FUNCTION: <s> BOOL b_do_move(void)
  662.  * PURPOSE : Do a move in current direction
  663.  *         :
  664.  * CREATION: 11/28/1988 13:08:14
  665.  */
  666. BOOL b_do_move(void)
  667. {
  668.    cline.w_command=_MOVE;
  669.    return TRUE;
  670. } /* BOOL b_do_move(void) */
  671.  
  672. /*<f>----------------------------------------
  673.  * FUNCTION: <s> BOOL b_do_fire(void)
  674.  * PURPOSE : Fire in current direction
  675.  *         :
  676.  * CREATION: 11/28/1988 13:19:04
  677.  */
  678. BOOL b_do_fire(void)
  679. {
  680.    cline.w_command=_FIRE;
  681.    return TRUE;
  682. } /* BOOL b_do_fire(void) */
  683.  
  684. /*<f>----------------------------------------
  685.  * FUNCTION: <s> BOOL b_loaded(PSTR s)
  686.  * PURPOSE : Check that G is loaded, place answer in S
  687.  *         :
  688.  * CREATION: 11/28/1988 13:20:32
  689.  */
  690. BOOL b_loaded(PSTR s)
  691. {
  692.    if (!b_parse_arg(&cline.arg1,s)) {
  693.       cerror=_SYNTAX;
  694.       return FALSE;
  695.    }
  696.  
  697.    if (cline.arg1.n_ArgType!=SYMBOL) {
  698.       cerror=_SYMREQ1;
  699.       return FALSE;
  700.    }
  701.  
  702.    cline.w_command=_LOADED;
  703.    return TRUE;
  704. } /* BOOL b_loaded(PSTR s) */
  705.  
  706. /*<f>----------------------------------------
  707.  * FUNCTION: <s> BOOL b_do_return(void)
  708.  * PURPOSE : Do a return statement
  709.  *         :
  710.  * CREATION: 11/28/1988 13:32:35
  711.  */
  712. BOOL b_do_return(void)
  713. {
  714.    cline.w_command=_RETURN;
  715.    return TRUE;
  716. } /* BOOL b_do_return(void) */
  717.  
  718. /*<f>----------------------------------------
  719.  * FUNCTION: <s> void v_add_resolve(PSTR s)
  720.  * PURPOSE : Add lineref for future resolution
  721.  *         :
  722.  * CREATION: 11/29/1988 07:03:11
  723.  */
  724. void v_add_resolve(PSTR s)
  725. {
  726.    strcpy(link[nlinks++].label,s);
  727. } /* void v_add_resolve(PSTR s) */
  728.  
  729. /*<f>----------------------------------------
  730.  * FUNCTION: <s> void v_conclude_resolves(void)
  731.  * PURPOSE : Conclude linking procedure
  732.  *         :
  733.  * CREATION: 11/29/1988 10:53:55
  734.  */
  735. void v_conclude_resolves(void)
  736. {
  737. int a;
  738.  
  739.    for (a=0; a<nlines; a++) {
  740.       v_check_link(&line[a]->arg1);
  741.       v_check_link(&line[a]->arg2);
  742.       v_check_link(&line[a]->arg3);
  743.    }
  744. } /* void v_conclude_resolves(void) */
  745.  
  746. /*<f>----------------------------------------
  747.  * FUNCTION: <s> void v_check_link(p_ARG parg)
  748.  * PURPOSE : Check if argument is an unresolved line reference
  749.  *         :
  750.  * CREATION: 11/29/1988 10:56:39
  751.  */
  752. void v_check_link(p_ARG parg)
  753. {
  754. char s[20];
  755. int  a;
  756.  
  757.    if (parg->n_ArgType!=LINEREF || parg->n_value!=UNUSED)
  758.       return;
  759.  
  760.    strcpy(s,link[resolve++].label);
  761.  
  762.    a=n_find_label(s);
  763.  
  764.    if (a==UNUSED)
  765.       cprintf("Unresolved reference \"%s\"\n\r",s);
  766.    else
  767.       parg->n_value=a;
  768.  
  769. } /* void v_check_link(p_ARG parg) */
  770.  
  771. /*<f>----------------------------------------
  772.  * FUNCTION: <s> void v_list_structure(void)
  773.  * PURPOSE : List internal data structure to screen
  774.  *         :
  775.  * CREATION: 11/29/1988 11:28:43
  776.  */
  777. void v_list_structure(void)
  778. {
  779. int a;
  780.  
  781.    cprintf("\n\r------ SYMBOLS ---------\n\r");
  782.    for (a=0; a<nvars; a++) cprintf("%2d, %s\n\r",a,vars[a]);
  783.    cprintf("\n\r----- RESOLVES ---------\n\r");
  784.    for (a=0; a<nlinks; a++) cprintf("%2d, %s\n\r",a,link[a].label);
  785.    cprintf("\n\r-----  LABELS  ---------\n\r");
  786.    for (a=0; a<nlabels; a++) cprintf("%2d, %s\n\r",a,labels[a].c_label);
  787.    cprintf("\n\r-----  LINES  ----------\n\r");
  788.    for (a=0; a<nlines; a++) cprintf("%2d, %d (%d) (%d) (%d)\n\r",a,line[a]->w_command,
  789.       line[a]->arg1.n_value,
  790.       line[a]->arg2.n_value,
  791.       line[a]->arg3.n_value);
  792.  
  793. } /* void v_list_structure(void) */
  794.  
  795. /*<f>----------------------------------------
  796.  * FUNCTION: <s> void v_write_code(PSTR s)
  797.  * PURPOSE : Write Binary data to disk
  798.  *         :
  799.  * CREATION: 11/29/1988 11:30:15
  800.  */
  801. void v_write_code(PSTR s)
  802. {
  803. FILE *fp;
  804. int a;
  805. char drive[10], dir[60], name[20], ext[10];
  806.  
  807.    fnsplit(s,drive,dir,name,ext);
  808.  
  809.    if ((fp=fopen(strcat(name,".BIN"),"wb"))==NULL) {
  810.       cprintf("Cannot open %s to output\n\r",name);
  811.       b_good_pass=FALSE;
  812.    } else {
  813.  
  814.       putw(nlines,fp);
  815.       for (a=0; a<nlines; a++) {
  816.          putw(line[a]->w_command,fp); putw(line[a]->phyline,fp);
  817.          putw(line[a]->arg1.n_ArgType,fp); putw(line[a]->arg1.n_value,fp);
  818.          putw(line[a]->arg2.n_ArgType,fp); putw(line[a]->arg2.n_value,fp);
  819.          putw(line[a]->arg3.n_ArgType,fp); putw(line[a]->arg3.n_value,fp);
  820.       }
  821.  
  822.       fclose(fp);
  823.    }
  824. } /* void v_write_code(PSTR s) */
  825.  
  826. /*<f>----------------------------------------
  827.  * FUNCTION: <s> BOOL b_do_set(PSTR s1, PSTR s2)
  828.  * PURPOSE : Set s1 to s2
  829.  *         :
  830.  * CREATION: 11/29/1988 19:15:45
  831.  */
  832. BOOL b_do_set(PSTR s1, PSTR s2)
  833. {
  834.    if (!b_parse_arg(&cline.arg1,s1)) {
  835.       cerror=_SYNTAX;
  836.       return FALSE;
  837.    }
  838.    if (!b_parse_arg(&cline.arg2,s2)) {
  839.       cerror=_SYNTAX;
  840.       return FALSE;
  841.    }
  842.  
  843.    if (cline.arg1.n_ArgType!=SYMBOL) {
  844.       cerror=_SYMREQ1;
  845.       return FALSE;
  846.    }
  847.  
  848.    cline.w_command=_SET;
  849.    return TRUE;
  850.  
  851. } /* BOOL b_do_set(PSTR s1, PSTR s2) */
  852.  
  853. /*<f>----------------------------------------
  854.  * FUNCTION: <s>BOOL b_do_add(PSTR s1, PSTR s2)
  855.  * PURPOSE : Add an argument to a symbol
  856.  *         :
  857.  * CREATION: 12/02/1988 10:01:44
  858.  */
  859. BOOL b_do_add(PSTR s1, PSTR s2)
  860. {
  861.    if (!b_parse_arg(&cline.arg1,s1)) {
  862.       cerror=_SYNTAX;
  863.       return FALSE;
  864.    }
  865.    if (!b_parse_arg(&cline.arg2,s2)) {
  866.       cerror=_SYNTAX;
  867.       return FALSE;
  868.    }
  869.  
  870.    if (cline.arg1.n_ArgType!=SYMBOL) {
  871.       cerror=_SYMREQ1;
  872.       return FALSE;
  873.    }
  874.  
  875.    cline.w_command=_ADD;
  876.    return TRUE;
  877.  
  878. } /* BOOL b_do_add(PSTR s1, PSTR s2) */
  879.  
  880. /*<f>----------------------------------------
  881.  * FUNCTION: <s> BOOL b_do_rand(PSTR s1, PSTR s2)
  882.  * PURPOSE : Set s1 to a random number within 1-s2
  883.  *         :
  884.  * CREATION: 12/02/1988 10:02:41
  885.  */
  886. BOOL b_do_rand(PSTR s1, PSTR s2)
  887. {
  888.    if (!b_parse_arg(&cline.arg1,s1)) {
  889.       cerror=_SYNTAX;
  890.       return FALSE;
  891.    }
  892.    if (!b_parse_arg(&cline.arg2,s2)) {
  893.       cerror=_SYNTAX;
  894.       return FALSE;
  895.    }
  896.  
  897.    if (cline.arg1.n_ArgType!=SYMBOL) {
  898.       cerror=_SYMREQ1;
  899.       return FALSE;
  900.    }
  901.  
  902.    cline.w_command=_RAND;
  903.    return TRUE;
  904.  
  905. } /* BOOL b_do_rand(PSTR s1, PSTR s2) */
  906.  
  907. /*<f>----------------------------------------
  908.  * FUNCTION: <s> void v_free_compiler_ram(void)
  909.  * PURPOSE : Free up ram used by compiler
  910.  *         :
  911.  * CREATION: 12/05/1988 16:25:19
  912.  */
  913. void v_free_compiler_ram(void)
  914. {
  915. int a;
  916.  
  917.    for (a=0; a<nlines; a++)
  918.       free(line[a]);
  919. } /* void v_free_compiler_ram(void) */
  920.  
  921. /*<f>----------------------------------------
  922.  * FUNCTION: <s> BOOL b_make_radar(PSTR s)
  923.  * PURPOSE : Do a radar command
  924.  *         :
  925.  * CREATION: 12/06/1988 11:44:45
  926.  */
  927. BOOL b_make_radar(PSTR s)
  928. {
  929.    if (!b_parse_arg(&cline.arg1,s)) {
  930.       cerror=_SYNTAX;
  931.       return FALSE;
  932.    }
  933.  
  934.    if (cline.arg1.n_ArgType!=SYMBOL) {
  935.       cerror=_SYMREQ1;
  936.       return FALSE;
  937.    }
  938.  
  939.    cline.w_command=_RADAR;
  940.    return TRUE;
  941. } /* BOOL b_make_radar(PSTR s) */
  942.  
  943. /*<f>----------------------------------------
  944.  * FUNCTION: <s> BOOL b_make_scan(PSTR s1, PSTR s2)
  945.  * PURPOSE : Do a SCAN command
  946.  *         :
  947.  * CREATION: 12/06/1988 11:45:08
  948.  */
  949. BOOL b_make_scan(PSTR s1, PSTR s2)
  950. {
  951.    if (!b_parse_arg(&cline.arg1,s1)) {
  952.       cerror=_SYNTAX;
  953.       return FALSE;
  954.    }
  955.    if (!b_parse_arg(&cline.arg2,s2)) {
  956.       cerror=_SYNTAX;
  957.       return FALSE;
  958.    }
  959.  
  960.    if (cline.arg1.n_ArgType!=SYMBOL) {
  961.       cerror=_SYMREQ1;
  962.       return FALSE;
  963.    }
  964.  
  965.    cline.w_command=_SCAN;
  966.    return TRUE;
  967. } /* BOOL b_make_scan(PSTR s1, PSTR s2) */